home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / raytrace / renaisnc / rcnstrct.lha / Reconstruct / iris.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-04  |  8.0 KB  |  422 lines
  1. #include <gl.h>
  2. #include <device.h>
  3. #include <stdio.h>
  4.  
  5. #include "Reconstruct.h"
  6.  
  7. #ifndef NULL
  8. #define NULL 0L
  9. #endif
  10.  
  11. extern int Animating;
  12.  
  13. static long win;
  14. static int AnimationFrozen;
  15. static int Outline = FALSE, ShowPoint = FALSE;
  16.  
  17. static double xL, xH, yL, yH, xl, yl, xh, yh;
  18.  
  19. AnimateInitialize( XL,YL,XH,YH) 
  20.      double XL, XH, YL, YH;
  21. {
  22.   if (!Animating) return;
  23.  
  24.   xL = xl = XL; xH = xh = YH;
  25.   yL = yl = YL; yH = yh = YH;
  26.   ortho2( (Coord) xL, (Coord) xH, (Coord) yL, (Coord) yH );
  27. }
  28.  
  29.  
  30. AnimateShadeCell( Boundary, Sample )
  31.      RectType *Boundary;
  32.      SampleData *Sample;
  33. {
  34.   short r, g, b;
  35.  
  36.   if (!Animating || AnimationFrozen) return;
  37.  
  38.   r = Sample->Ave.r*256;
  39.   g = Sample->Ave.g*256;  
  40.   b = Sample->Ave.b*256;
  41.  
  42.   if (r > 255) r = 255;  if (r < 0) r = 0;
  43.   if (g > 255) g = 255;  if (g < 0) g = 0;
  44.   if (b > 255) b = 255;  if (b < 0) b = 0;
  45.  
  46.   bgnpolygon();
  47.   {
  48.     double p[2];
  49.  
  50.     RGBcolor( r, g, b );
  51.     p[0] = Boundary->xL;
  52.     p[1] = Boundary->yL;
  53.     v2d( p );
  54.  
  55.  
  56.     p[0] = Boundary->xL;
  57.     p[1] = Boundary->yH;
  58.     v2d( p );
  59.  
  60.     p[0] = Boundary->xH;
  61.     p[1] = Boundary->yH;
  62.     v2d( p );
  63.  
  64.     p[0] = Boundary->xH;
  65.     p[1] = Boundary->yL;
  66.     v2d( p );
  67.  
  68.   }
  69.   endpolygon();
  70.  
  71.  
  72.   if (Outline) {
  73.     bgnclosedline();
  74.     {
  75.       double p[2];
  76.  
  77.       RGBcolor( 255, 255, 255 );
  78.  
  79.       p[0] = Boundary->xL;
  80.       p[1] = Boundary->yL;
  81.       v2d( p );
  82.  
  83.       p[0] = Boundary->xL;
  84.       p[1] = Boundary->yH;
  85.       v2d( p );
  86.  
  87.       p[0] = Boundary->xH;
  88.       p[1] = Boundary->yH;
  89.       v2d( p );
  90.  
  91.       p[0] = Boundary->xH;
  92.       p[1] = Boundary->yL;
  93.       v2d( p );
  94.     }
  95.     endclosedline();
  96.   }
  97.  
  98.   if (ShowPoint) {
  99.     bgnpoint();
  100.     { 
  101.       double p[2];
  102.  
  103.       p[0] = Sample->Xs; p[1] = Sample->Ys;
  104.       RGBcolor( (short) 255, (short) 255, (short) 255 );
  105.       v2d( p );
  106.     }
  107.     endpoint();
  108.   }
  109. }
  110.  
  111.  
  112. void Animate (Animation)
  113.      char *Animation;
  114. {
  115.   Animating = TRUE;
  116.   
  117.   foreground();
  118.  
  119.   /* Set up default window size and options*/
  120.   prefsize( 768, 768 );
  121.   maxsize ( 1024, 1024 );
  122.   minsize (   32, 32 );
  123.   keepaspect( 1, 1 );
  124.  
  125.   /* Open the window */
  126.   win = winopen("Delaunay");
  127.  
  128.   /* Initialize the graphics state */
  129.   RGBmode();
  130.   singlebuffer(); 
  131.   gconfig();
  132.   ortho2(-1.0,1.0,-1.0,1.0);
  133.   clear();
  134.  
  135.   /* Set up devices to queue */
  136.   qdevice( REDRAW );
  137.   qdevice( WINQUIT );
  138.   qdevice( WINFREEZE );
  139.   qdevice( WINTHAW );
  140.  
  141.   qdevice( LEFTMOUSE );
  142.   qdevice( MIDDLEMOUSE );
  143.   tie( MIDDLEMOUSE, MOUSEX, MOUSEY );
  144.   qdevice( RIGHTMOUSE );
  145.  
  146.   qdevice( LEFTARROWKEY );
  147.   qdevice( RIGHTARROWKEY );
  148.   qdevice( DOWNARROWKEY );
  149.   qdevice( UPARROWKEY );
  150.  
  151.   qdevice( F1KEY );
  152.   qdevice( F2KEY );
  153.   qdevice( F3KEY );
  154.   qdevice( F4KEY );
  155.   qdevice( F5KEY );
  156.  
  157.   unqdevice( INPUTCHANGE );
  158. } 
  159.  
  160.  
  161. static void AnimateReDraw()
  162. {
  163.   extern HierarchicalRegion Root;
  164.   extern RectType RootBoundary;
  165.   register HierarchicalRegion *Node;
  166.   RectType LeftBoundary, RightBoundary, Boundary, Overlap;
  167.  
  168.   /* This stack is used to avoid the expense of recursion */
  169.   HierarchicalRegion *NodeStack[MAX_DEPTH];
  170.   RectType BoundaryStack[MAX_DEPTH];
  171.   int levelStack[MAX_DEPTH];
  172.   int nStack, level;
  173.   
  174.   if (AnimationFrozen) return;
  175.   
  176.   
  177.   /* Make sure the transformation is restored to the right state */
  178.   reshapeviewport();
  179.   
  180.  
  181.   /* Start with the root node on the stack */
  182.   nStack = 0;
  183.   NodeStack[nStack] = &Root;
  184.   BoundaryStack[nStack] = RootBoundary;
  185.   levelStack[nStack++] = 0;
  186.  
  187.   while (nStack > 0) {
  188.  
  189.     /* Get the next node to process from the stack */
  190.     Node = NodeStack[--nStack];
  191.     Boundary = BoundaryStack[nStack];
  192.     level    = levelStack[nStack];
  193.     
  194.     /* Follow the tree down a leaf, pushing the side branches.
  195.      */
  196.     while (! IsLeaf(Node)) {
  197.  
  198.       SplitBoundary( TRUE, Node->splitDirection, Node->splitValue,
  199.             &Boundary, &LeftBoundary );
  200.       if (Node->Left) {
  201.     NodeStack[nStack] = Node->Left;
  202.     BoundaryStack[nStack] = LeftBoundary;
  203.     levelStack[nStack++] = level+1;
  204.       }
  205.       SplitBoundary( FALSE, Node->splitDirection, Node->splitValue, 
  206.             &Boundary, &RightBoundary );
  207.       if (Node->Right) {
  208.     if (nStack >= MAX_DEPTH) {
  209.       fprintf( stderr, "Filter stack overflow!\n"  );
  210.       abort();
  211.     }
  212.     NodeStack[nStack] = Node->Right;
  213.     BoundaryStack[nStack] = RightBoundary;
  214.     levelStack[nStack++] = level+1;
  215.       }
  216.  
  217.       /* Get the next node to process from the stack */
  218.       Node = NodeStack[--nStack];
  219.       Boundary = BoundaryStack[nStack];
  220.       level    = levelStack[nStack];
  221.     }
  222.   
  223.     if (Node == NULL)
  224.       continue;        /* Dead end, go back to the stack loop */
  225.   
  226.     AnimateShadeCell( &Boundary, Node->Sample );
  227.   }
  228. }
  229.  
  230.  
  231.  
  232. AnimateDoEvent()
  233. {
  234.   Device dev;
  235.   short  data;
  236.   double range;
  237.   int update = FALSE;
  238.  
  239.   if (!Animating) return;
  240.  
  241.   while (qtest()) {
  242.     dev=qread(&data) ;
  243.     switch (dev) 
  244.       {
  245.       case REDRAW:
  246.     AnimateReDraw(); 
  247.     break;
  248.       case WINQUIT:
  249.     exit(0);
  250.       case WINFREEZE:
  251.     AnimationFrozen = TRUE;
  252.     break;
  253.       case WINTHAW:
  254.     AnimationFrozen = FALSE;
  255.     winset( win );
  256.     break;
  257.     
  258.       case F1KEY:
  259.     if (data != 1) break; /* Button down only */
  260.     /* Reset */
  261.     xL = xl; yL = yl; xH=xh; yH=yh;
  262.     update = TRUE;
  263.     break;
  264.     
  265.       case F2KEY:
  266.     if (data != 1) break; /* Button down only */
  267.     Outline = !Outline;
  268.     update = TRUE;;
  269.     break;
  270.     
  271.  
  272.       case F3KEY:
  273.     if (data != 1) break; /* Button down only */
  274.     ShowPoint = !ShowPoint;
  275.     update = TRUE;
  276.     break;
  277.  
  278.       case F4KEY:
  279.     if (data != 1) break;  /* Button down only */
  280.     fprintf( stderr, "%lf %lf %lf%lf\n", xL, yL, xH, yH );
  281.     break;
  282.  
  283.       case F5KEY:
  284.     if (data != 1) break;
  285.     fprintf( stderr, "Enter box xl,yl,xh,yh: " );
  286.     {
  287.       FILE *term = fopen( "/dev/tty", "r" );
  288.       int n = fscanf ( term, "%lf %lf %lf %lf", &xL, &yL, &xH, &yH );
  289.       fclose(term);
  290.     }
  291.     update = TRUE;
  292.     break;
  293.  
  294.       case LEFTMOUSE:
  295.     if (data != 1) break; /* Button down only */
  296.     /* Zoom out */
  297.     range = xH - xL;
  298.     range *= 0.05;
  299.     xL -= range;
  300.     xH += range;
  301.     
  302.     range = yH - yL;
  303.     range *= 0.05;
  304.     yL -= range;
  305.     yH += range;
  306.     update = TRUE;
  307.     AnimateReDraw();
  308.     break; 
  309.  
  310.       case MIDDLEMOUSE:
  311.     {
  312.       static double xl, yl, xh, yh;
  313.       int x_origin, y_origin, x_size, y_size;
  314.  
  315.       getorigin( &x_origin, &y_origin );
  316.       getsize  ( &x_size  , &y_size   );
  317.  
  318.       if (data == 1) {  /* Button Down */
  319.         /* Next two events ought to be mousex and mousey */
  320.         dev = qread( &data );
  321.         xl = (double) (data - x_origin) * (xH - xL) / (x_size) + xL;
  322.         dev = qread( &data );
  323.         yl = (double) (data - y_origin) * (yH - yL) / (y_size) + yL;
  324.       } else {  /* Mouse Up */
  325.         /* Next two events ought to be mousex and mousey */
  326.         dev = qread( &data );
  327.         xh = (double) (data - x_origin) * (xH - xL) / (x_size) + xL;
  328.         dev = qread( &data );
  329.         yh = (double) (data - y_origin) * (yH - yL) / (y_size) + yL;
  330.         if (xl > xh) { xL = xh; xH = xl;} else { xL = xl; xH = xh; }
  331.         if (yl > yh) { yL = yh; yH = yl;} else { yL = yl; yH = yh; }
  332.         update = TRUE;
  333.       }
  334.       break;
  335.     }
  336.  
  337.       case RIGHTMOUSE:
  338.     if (data != 1) break; /* Button down only */
  339.     /* Zoom in */
  340.     range = xH - xL;
  341.     range *= 0.05;
  342.     xL += range;
  343.     xH -= range;
  344.     
  345.     range = yH - yL;
  346.     range *= 0.05;
  347.     yL += range;
  348.     yH -= range;
  349.     update = TRUE;
  350.     break;
  351.     
  352.       case LEFTARROWKEY:
  353.     if (data != 1) break; /* Button down only */
  354.     /* Move left (negative) */
  355.     range = xH - xL;
  356.     range *= .05;
  357.     xL -= range;
  358.     xH -= range;
  359.     update = TRUE;
  360.     break;
  361.     
  362.       case RIGHTARROWKEY:
  363.     if (data != 1) break; /* Button down only */
  364.     /* Move right (positive) */
  365.     range = xH - xL;
  366.     range *= .05;
  367.     xL += range;
  368.     xH += range;
  369.     update = TRUE;
  370.     break;
  371.     
  372.       case DOWNARROWKEY:
  373.     if (data != 1) break; /* Button down only */
  374.     /* Move down (negative) */
  375.     range = yH - yL;
  376.     range *= .05;
  377.     yL -= range;
  378.     yH -= range;
  379.     update = TRUE;
  380.     break;
  381.     
  382.       case UPARROWKEY:
  383.     if (data != 1) break; /* Button down only */
  384.     /* Move up (positive) */
  385.     range = yH - yL;
  386.     range *= .05;
  387.     yL += range;
  388.     yH += range;
  389.     update = TRUE;
  390.     break;
  391.     
  392.       }
  393.   }
  394.   if (update) {
  395.     ortho2( (Coord) xL, (Coord) xH, (Coord) yL, (Coord) yH );
  396.     RGBcolor(0,0,0); clear();
  397.     AnimateReDraw();
  398.   }    
  399.   return dev;
  400. }
  401.  
  402. int AnimateCheckInput()
  403. {
  404.   if (!Animating) return;
  405.  
  406.   while ( qtest() )
  407.     (void) AnimateDoEvent();
  408. }
  409.  
  410.  
  411. AnimateExit()
  412. {
  413.  
  414.   if (!Animating) return;
  415.  
  416.   do {}  while (AnimateDoEvent() != WINQUIT);
  417. }
  418.   
  419.  
  420.  
  421.  
  422.